package com.haojin.java;

import org.junit.Test;

import java.io.*;

/**
 * @author .29.
 * @create 2022-04-14 19:44
 */
/*
一、流的分类
1.操作数据单位：字节流，字符流
2.数据的流向：输入流，输出流
3.流的角色：节点流，处理流

二、流的体系结构
抽象基类             节点流（或文件流）         缓冲流（处理流的一种）
InputStream          FileInputStream         BufferedInputStream
OutputStream         FileOutputStream        BufferedOutputStream
Reader               FileReader              BufferedReader
Writer               FileWriter              BufferWriter
 */
public class FileWriterReaderTest {
    public static void main(String[] args) {
        File file = new File("hello.txt");
        System.out.println(file.getAbsoluteFile());
        File file1 = new File("day09\\hello.txt");
        System.out.println(file1);
    }
    /*
    将day09下的hello.txt文件内容读入程序中，并且输出到控制台

    说明点：
    1.read():返回读入的一个字符，如果达到文件末尾，返回-1
    2.异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
    3.读入的文件一定要存在，否则抛出异常：FileNotFoundException
     */
    @Test
    public void test1(){
        FileReader fileReader = null;
        try {
            //1.实例化File类的对象，指明要操作的文件
            File file = new File("hello.txt");
            //2.提供具体的流
            fileReader = new FileReader(file);
            //3.数据的读入
            //read():返回读入的一个字符，如果达到文件末尾，返回-1
//        int read = fileReader.read();
//        while(read !=-1){
//            System.out.print((char) read);
//            read = fileReader.read();
//        }
            //优化一波(语法上针对上面的修改)
            int read;
            while((read = fileReader.read()) != -1){
                System.out.print((char)read);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流的关闭操作
            try {
                if(fileReader != null)
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //对read()操作升级：使用read的重载方法
    @Test
    public void test2(){
        FileReader fr = null;
        try {
            //1.File类的实例化
            File file = new File("hello.txt");
            //2.FileReader流的实例化
            fr = new FileReader(file);
            //3.读入操作
            char[] cbuf = new char[5];
            int len;
            while ((len = fr.read(cbuf)) != -1){
//                方式一：
//                for (int i = 0; i < len; i++) {
//                    System.out.print(cbuf[i]);
//                }
                String s = new String(cbuf, 0, len);
                System.out.print(s);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fr != null){
                //4.资源的关闭
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    /*
    从内存中写出数据到硬盘的文件里

    说明：
    1.输出操作，对应的File可以不存在，不会报异常
               File对应硬盘中的文件如果不存在，在输出的过程中，会自动创建文件。
               File对应硬盘中的文件如果存在：
                     如果流使用的构造器是：FileWriter(file,false)/FileWriter(file):对原有文件的覆盖
                     如果流使用的构造器是：FileWriter(file,true):对原有文件基础上追加内容，不会覆盖

     */
    @Test
    public void test3()   {
        FileWriter fileWriter = null;
        try {
            //1.File类的实例化，指明写出到的文件
            File file = new File("hi.txt");
            //2.FileWriter的对象，用于数据的写出
            fileWriter = new FileWriter(file,false);
            //3.写出的操作
            fileWriter.write("hi,may be i am not a nice boy...\n");
            fileWriter.write("but i can be better by the way..\n");
            //4.资源的关闭
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fileWriter != null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
    @Test
    public void testFileReaderFileWriter()   {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            //File类的实例化
            File file1 = new File("hi.txt");
            File file2 = new File("hi hi hi.txt");
            //创建流的对象
            fr = new FileReader(file1);
            fw = new FileWriter(file2);
            //读取与写入操作
            char[] cbuf = new char[5];
            int len;
            while((len = fr.read(cbuf)) != -1){
                fw.write(cbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //资源的关闭
            try {
                if (fr != null)
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fw != null)
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}
